﻿using Library.AppWeb;
using MPR.Poker.Model.SYS;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;


namespace MPR.Poker.DALEntity.SYS
{
    public class DAL_Tournament
    {
        public DAL_Tournament()
        {
        }

        #region Insert/Update/Delete

        /// <summary>
        /// Thêm mới giải đấu tổng hợp
        /// </summary>
        /// <param name="objTournament"></param>
        /// <returns></returns>
        public ResultMessage Insert(SYS_Tournament objTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                //objResultMessage = CheckExist(objTournament);
                //if (objResultMessage.IsError) return objResultMessage;

                objResultMessage = InsertNoCheck(objTournament);
                if (objResultMessage.IsError) return objResultMessage;
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Insert, "Lỗi thêm giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> Insert");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Thêm giải đấu thành công", string.Empty);
        }

        /// <summary>
        /// Cập nhật giải đấu tổng hợp
        /// </summary>
        /// <param name="objTournament"></param>
        /// <returns></returns>
        public ResultMessage Update(SYS_Tournament objTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                objResultMessage = CheckExist(objTournament);
                if (objResultMessage.IsError) return objResultMessage;

                objResultMessage = UpdateNoCheck( objTournament);
                if (objResultMessage.IsError) return objResultMessage;
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Insert, "Lỗi cập nhật giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> Update");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Cập nhật giải đấu thành công", string.Empty);
        }

        /// <summary>
        /// Xóa giải đấu
        /// </summary>
        /// <param name="strTournamentID"></param>
        /// <returns></returns>
        public ResultMessage Delete(SYS_Tournament objTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            objResultMessage = CheckRelationship(objTournament);
            if (objResultMessage.IsError) return objResultMessage;

            objResultMessage = DeleteNoCheck(objTournament);

            return objResultMessage;
        }

        /// <summary>
        /// Xóa giải đấu
        /// </summary>
        /// <param name="intTournamentIDSys">Mã giải đấu</param>
        /// <param name="intDeletedTournament">Mã giải đấu</param>
        /// <returns></returns>
        public ResultMessage Delete(int intTournamentIDSys, int intDeletedTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_Tournament objTournament = new SYS_Tournament();
            objTournament.IDSys = intTournamentIDSys;

            objResultMessage = CheckRelationship(objTournament);
            if (objResultMessage.IsError) return objResultMessage;

            objResultMessage = DeleteNoCheck(objTournament);

            return objResultMessage;
        }

        /// <summary>
        /// Xóa giải đấu
        /// </summary>
        /// <param name="lstTournamentIDSys">List đối tượng giải đấu</param>
        /// <param name="intDeletedTournament">Mã giải đấu</param>
        /// <returns></returns>
        public ResultMessage Delete(List<int> lstTournamentIDSys, int intDeletedTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();

            foreach (int IDSys in lstTournamentIDSys)
            {
                SYS_Tournament objTournament = new SYS_Tournament();
                objTournament.IDSys = IDSys;

                objResultMessage = CheckRelationship(objTournament);
                if (objResultMessage.IsError) return objResultMessage;

                objResultMessage = DeleteNoCheck(objTournament);
                if (objResultMessage.IsError) return objResultMessage;
            }

            return objResultMessage;
        }

        /// <summary>
        /// Kiềm tra tồn tại giải đấu
        /// </summary>
        /// <param name="strID"></param>
        /// <param name="strTournamentID"></param>
        /// <returns></returns>
        public ResultMessage CheckExist(SYS_Tournament objTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_Tournament Tournament = new SYS_Tournament();

            try
            {
                using (PokerLife db = new PokerLife())
                {
                    Tournament = db.SYS_Tournaments.FirstOrDefault(i => i.IsDeleted == false & i.TournamentName == objTournament.TournamentName & i.IDSys != objTournament.IDSys);

                    if (Tournament != null && Tournament.TournamentName.Trim().Length > 0)
                    {
                        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "giải đấu đã tồn tại", string.Empty);
                    }
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "Lỗi kiểm tra tồn tại giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> CheckExist");
                return objResultMessage;
            }
            return objResultMessage;
        }

        /// <summary>
        /// Kiểm tra dữ liệu liên quan
        /// </summary>
        /// <param name="strTournamentID"></param>
        /// <returns></returns>
        public ResultMessage CheckRelationship(SYS_Tournament objTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                //using (PokerLife db = new PokerLife())
                //{
                //    SYS_Tournament user = db.SYS_Tournaments.FirstOrDefault(i => i.TournamentGroupIDSys == objTournamentGroup.IDSys);

                //    if (user != null && user.UID.Trim().Length > 0)
                //    {
                //        objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.No_Error, "Có dữ liệu liên quan đến nhóm giải đấu", string.Empty);
                //    }
                //}
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.CheckData, "Lỗi kiểm tra dữ liệu liên quan giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> CheckRelationship");
                return objResultMessage;
            }
            return objResultMessage;
        }

        /// <summary>
        /// Thêm mới giải đấu không cần kiểm tra
        /// </summary>
        /// <param name="objTournament"></param>
        /// <returns></returns>
        public ResultMessage InsertNoCheck(SYS_Tournament objTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            SYS_Tournament Tournament = new SYS_Tournament();

            try
            {
                Library.DataAccess.IData objIData = Library.DataAccess.Data.CreateData(DAL_Globals.ConnectString);
                objIData.ConnectNoEncrypt();
                SqlParameter[] para = new SqlParameter[10];
                para[0] = new SqlParameter("@TournamentName", objTournament.TournamentName);
                para[1] = new SqlParameter("@BeginDate", objTournament.BeginDate);
                para[2] = new SqlParameter("@EndDate", objTournament.EndDate);
                para[3] = new SqlParameter("@Description", objTournament.Description);
                para[4] = new SqlParameter("@ImageUrl", objTournament.ImageUrl);
                para[5] = new SqlParameter("@AwardTotal", objTournament.AwardTotal);
                para[6] = new SqlParameter("@StepNumber", objTournament.StepNumber);
                para[7] = new SqlParameter("@IsStepChoosed", objTournament.IsStepChoosed);
                para[8] = new SqlParameter("@IsEnd", objTournament.IsEnd);
                para[9] = new SqlParameter("@IsActived", objTournament.IsActived);

                objIData.CreateStoredProcedue("sp_SYS_Tournament_ADD");
                objIData.AddParameter(para);
                objIData.ExecProcedure();

                DAL_Event.Insert("Thêm mới giải đấu - " + Tournament.TournamentName.ToString(), 0, ResultMessage.ErrorTypes.Insert.ToString());
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Insert, "Lỗi thêm giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> Insert");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Thêm giải đấu thành công", string.Empty);
        }

        /// <summary>
        /// Cập nhật giải đấu không cần kiểm tra
        /// </summary>
        /// <param name="objTournament"></param>
        /// <returns></returns>
        public ResultMessage UpdateNoCheck(SYS_Tournament objTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                Library.DataAccess.IData objIData = Library.DataAccess.Data.CreateData(DAL_Globals.ConnectString);
                objIData.ConnectNoEncrypt();
                SqlParameter[] para = new SqlParameter[11];
                para[0] = new SqlParameter("@IDSys", objTournament.IDSys);
                para[1] = new SqlParameter("@TournamentName", objTournament.TournamentName);
                para[2] = new SqlParameter("@BeginDate", objTournament.BeginDate);
                para[3] = new SqlParameter("@EndDate", objTournament.EndDate);
                para[4] = new SqlParameter("@Description", objTournament.Description);
                para[5] = new SqlParameter("@ImageUrl", objTournament.ImageUrl);
                para[6] = new SqlParameter("@AwardTotal", objTournament.AwardTotal);
                para[7] = new SqlParameter("@StepNumber", objTournament.StepNumber);
                para[8] = new SqlParameter("@IsStepChoosed", objTournament.IsStepChoosed);
                para[9] = new SqlParameter("@IsEnd", objTournament.IsEnd);
                para[10] = new SqlParameter("@IsActived", objTournament.IsActived);

                objIData.CreateStoredProcedue("sp_SYS_Tournament_UPD");
                objIData.AddParameter(para);
                objIData.ExecProcedure();

                DAL_Event.Insert("Cập nhật giải đấu - " + objTournament.TournamentName.ToString(), 0, ResultMessage.ErrorTypes.Update.ToString());
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Update, "Lỗi cập nhật giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> Update");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Cập nhật giải đấu thành công", string.Empty);
        }

        /// <summary>
        /// Xóa giải đấu không cần kiểm tra
        /// </summary>
        /// <param name="objTournament"></param>
        /// <returns></returns>
        public ResultMessage DeleteNoCheck(SYS_Tournament objTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                Library.DataAccess.IData objIData = Library.DataAccess.Data.CreateData(DAL_Globals.ConnectString);
                objIData.ConnectNoEncrypt();
                SqlParameter[] para = new SqlParameter[1];
                para[0] = new SqlParameter("@IDSys", objTournament.IDSys);               

                objIData.CreateStoredProcedue("sp_SYS_Tournament_DEL");
                objIData.AddParameter(para);
                objIData.ExecProcedure();

                DAL_Event.Insert("Xóa giải đấu - " + objTournament.TournamentName.ToString(), 0, ResultMessage.ErrorTypes.Delete.ToString());

            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.Delete, "Lỗi xóa giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> DeleteNoCheck");
                return objResultMessage;
            }
            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Xóa giải đấu thành công", string.Empty);
        }               

        #endregion

        #region Load/Search/Select

        /// <summary>
        /// Lấy thông tin giải đấu
        /// </summary>
        /// <param name="objTournament"></param>
        /// <param name="strID"></param>
        /// <returns></returns>
        public ResultMessage LoadInfo(ref SYS_Tournament objTournament, int intTournamentIDSys)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                Library.DataAccess.IData objIData = Library.DataAccess.Data.CreateData(DAL_Globals.ConnectString);
                objIData.ConnectNoEncrypt();
                objIData.CreateStoredProcedue("sp_SYS_Tournament_SEL");
                objIData.AddParameter("@IDSys", intTournamentIDSys);

                DataTable dt = objIData.GetDataTableProcedure();
                objTournament = Library.AppWeb.ConvertData.ConvertToModel<SYS_Tournament>(dt);

            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.LoadInfo, "Lấy thông tin giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> LoadInfo");
                return objResultMessage;
            }
            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy thông tin giải đấu thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách giải đấu
        /// </summary>
        /// <param name="dtTournament"></param>
        /// <returns></returns>
        public ResultMessage SearchData(ref DataTable dtTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            dtTournament = new DataTable();

            try
            {
                using (PokerLife db = new PokerLife())
                {
                    dtTournament = ConvertData.ConvertToDataTable<SYS_Tournament>(db.SYS_Tournaments.Where(i => i.IsDeleted == false).ToList());
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SearchData, "Lấy thông tin giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> LoadInfo");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy danh sách giải đấu thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách giải đấu dạng List
        /// </summary>
        /// <param name="lstTournament"></param>
        /// <returns></returns>
        public ResultMessage SelectToList(ref List<SYS_Tournament> lstTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    var Tournament = from gu in db.SYS_Tournaments
                               where gu.IsDeleted == false
                               orderby gu.OrderIndex
                               select gu;
                    lstTournament = Tournament.ToList();
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SelectData, "Lấy thông tin giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> SelectToList");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy danh sách giải đấu thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách giải đấu dạng List
        /// </summary>
        /// <param name="lstTournament">Đối tượng giải đấu</param>
        /// <param name="intPageSize">Số lượng Record một trang</param>
        /// <param name="intPageNumber">Lấy trang số mấy</param>
        /// <returns></returns>
        public ResultMessage SelectToList(ref List<SYS_Tournament> lstTournament, int intPageSize, int intPageNumber)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                using (PokerLife db = new PokerLife())
                {
                    var Tournament = from gu in db.SYS_Tournaments
                               where gu.IsDeleted == false
                               orderby gu.OrderIndex
                               select gu;

                    lstTournament = Tournament.Skip((intPageNumber - 1) * intPageSize).Take(intPageSize).ToList();
                }
            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SelectData, "Lấy thông tin giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> SelectToList");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy danh sách giải đấu thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách giải đấu để Cache
        /// </summary>
        /// <param name="lstTournament"></param>
        /// <returns></returns>
        public ResultMessage SelectToCache(ref List<SYS_Tournament> lstTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            try
            {
                Library.DataAccess.IData objIData = Library.DataAccess.Data.CreateData(DAL_Globals.ConnectString);
                objIData.ConnectNoEncrypt();
                objIData.CreateStoredProcedue("sp_SYS_Tournament_SRH");

                DataTable dt = objIData.GetDataTableProcedure();
                lstTournament = Library.AppWeb.ConvertData.ConvertToList<SYS_Tournament>(dt);

            }
            catch (Exception objEx)
            {
                objResultMessage = new ResultMessage(true, ResultMessage.ErrorTypes.SelectData, "Lấy Cache danh sách giải đấu", objEx);
                DAL_Error.Insert(objResultMessage, 0, "DAL_Tournament --> SelectToListCache");
                return objResultMessage;
            }

            return new ResultMessage(false, ResultMessage.ErrorTypes.No_Error, "Lấy Cache danh sách giải đấu thành công", string.Empty);
        }

        /// <summary>
        /// Lấy danh sách giải đấu từ Cache
        /// </summary>
        /// <param name="lstTournament"></param>
        /// <returns></returns>
        public ResultMessage SelectToListCache(ref List<SYS_Tournament> lstTournament)
        {
            ResultMessage objResultMessage = new ResultMessage();
            //objResultMessage = MPR.Poker.DALEntity.DataCache.GetDataCache.GetTournament(ref lstTournament);
            return objResultMessage;
        }

        #endregion
    }
}
